package com.jay.tools.utils;

import android.annotation.TargetApi;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.os.Build;
import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class StringUtils {

    /**
     * 格式化价格
     *
     * @param price
     * @return
     */
    public static DecimalFormat getFromat(int price) {
        String t = String.valueOf(price);
        int length = t.length();
        String format = "";
        if (length >= 3) {
            String last = t.substring(t.length() - 1);
            String last2 = t.substring(t.length() - 2);
            if (last2.equals("00")) {
                format = "0";
            } else if (last.equals("0")) {
                format = "0.0";
            } else {
                format = "0.00";
            }
        } else if (length == 2) {
            String last = t.substring(t.length() - 1);
            if (last.equals("0")) {
                format = "0.0";
            } else {
                format = "0.00";
            }
        } else {
            if (price == 0) {
                format = "0";
            } else {
                format = "0.00";
            }
        }
        return new DecimalFormat(format);
    }

    /**
     * 判断str1和str2是否相同
     */
    public static boolean equals(String str1, String str2) {
        return str1 == str2 || str1 != null && str1.equals(str2);
    }

    /**
     * 判断str1和str2是否相同(不区分大小写)
     */
    public static boolean equalsIgnoreCase(String str1, String str2) {
        return str1 != null && str1.equalsIgnoreCase(str2);
    }

    /**
     * 判断字符串str1是否包含字符串str2
     *
     * @param str1 源字符串
     * @param str2 指定字符串
     * @return true源字符串包含指定字符串，false源字符串不包含指定字符串
     */
    public static boolean contains(String str1, String str2) {
        return str1 != null && str1.contains(str2);
    }

    /**
     * 字符数组转字符串
     *
     * @param join
     * @param strAry
     * @return
     */
    public static String join(String join, String[] strAry) {
        if (strAry == null)
            return "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < strAry.length; i++) {
            if (TextUtils.isEmpty(strAry[i]))
                continue;
            if (i == (strAry.length - 1)) {
                sb.append(strAry[i]);
            } else {
                sb.append(strAry[i]).append(join);
            }
        }

        return new String(sb);
    }

    /**
     * 将文本复制到剪贴板
     *
     * @param text
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public static void copyTextToClipBoard(String text, Context context) {
        try {
            ClipboardManager clipboard = (ClipboardManager) context
                    .getSystemService(Context.CLIPBOARD_SERVICE);
            clipboard.setPrimaryClip(ClipData.newPlainText(null, text));
            ToastUtil.toast(context, "已复制到剪贴板");
        } catch (Exception e) {
            ToastUtil.toast(context, "未复制内容");
        }
    }

    /********************* TODO 正则表达式 *******************/
    /**
     * 正则工具类-http://blog.csdn.net/xyang81/article/details/7706408 <br>
     * 提供验证邮箱、手机号、电话号码、身份证号码、数字等方法
     */
    /**
     * 过滤所有以<开头以>结尾的标签
     */
    private final static String regxpForHtml = "<([^>]*)>";

    /**
     * 找出IMG标签
     */
    private final static String regxpForImgTag = "<\\s*img\\s+([^>]*)\\s*>";

    /**
     * 找出IMG标签的SRC属性
     */
    private final static String regxpForImaTagSrcAttrib = "src=\"([^\"]+)\"";

    /**
     * 基本功能：替换标记以正常显示
     * <p/>
     *
     * @param input
     * @return String
     */
    public String replaceTag(String input) {
        if (!hasSpecialChars(input)) {
            return input;
        }
        StringBuffer filtered = new StringBuffer(input.length());
        char c;
        for (int i = 0; i <= input.length() - 1; i++) {
            c = input.charAt(i);
            switch (c) {
                case '<':
                    filtered.append("&lt;");
                    break;
                case '>':
                    filtered.append("&gt;");
                    break;
                case '"':
                    filtered.append("&quot;");
                    break;
                case '&':
                    filtered.append("&amp;");
                    break;
                default:
                    filtered.append(c);
            }

        }
        return (filtered.toString());
    }

    /**
     * 基本功能：判断标记是否存在
     * <p/>
     *
     * @param input
     * @return boolean
     */
    public boolean hasSpecialChars(String input) {
        boolean flag = false;
        if ((input != null) && (input.length() > 0)) {
            char c;
            for (int i = 0; i <= input.length() - 1; i++) {
                c = input.charAt(i);
                switch (c) {
                    case '>':
                        flag = true;
                        break;
                    case '<':
                        flag = true;
                        break;
                    case '"':
                        flag = true;
                        break;
                    case '&':
                        flag = true;
                        break;
                }
            }
        }
        return flag;
    }

    /**
     * 基本功能：过滤所有以"<"开头以">"结尾的标签
     * <p/>
     *
     * @param str
     * @return String
     */
    public static String filterHtml(String str) {
        Pattern pattern = Pattern.compile(regxpForHtml);
        Matcher matcher = pattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        boolean result1 = matcher.find();
        while (result1) {
            matcher.appendReplacement(sb, "");
            result1 = matcher.find();
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * 基本功能：过滤指定标签
     * <p/>
     *
     * @param str
     * @param tag 指定标签
     * @return String
     */
    public static String fiterHtmlTag(String str, String tag) {
        String regxp = "<\\s*" + tag + "\\s+([^>]*)\\s*>";
        Pattern pattern = Pattern.compile(regxp);
        Matcher matcher = pattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        boolean result1 = matcher.find();
        while (result1) {
            matcher.appendReplacement(sb, "");
            result1 = matcher.find();
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * 基本功能：替换指定的标签
     * <p/>
     *
     * @param str
     * @param beforeTag 要替换的标签
     * @param tagAttrib 要替换的标签属性值
     * @param startTag  新标签开始标记
     * @param endTag    新标签结束标记
     * @return String
     * @如：替换img标签的src属性值为[img]属性值[/img]
     */
    public static String replaceHtmlTag(String str, String beforeTag, String tagAttrib,
                                        String startTag, String endTag) {
        String regxpForTag = "<\\s*" + beforeTag + "\\s+([^>]*)\\s*>";
        String regxpForTagAttrib = tagAttrib + "=\"([^\"]+)\"";
        Pattern patternForTag = Pattern.compile(regxpForTag);
        Pattern patternForAttrib = Pattern.compile(regxpForTagAttrib);
        Matcher matcherForTag = patternForTag.matcher(str);
        StringBuffer sb = new StringBuffer();
        boolean result = matcherForTag.find();
        while (result) {
            StringBuffer sbreplace = new StringBuffer();
            Matcher matcherForAttrib = patternForAttrib.matcher(matcherForTag.group(1));
            if (matcherForAttrib.find()) {
                matcherForAttrib.appendReplacement(sbreplace, startTag + matcherForAttrib.group(1)
                        + endTag);
            }
            matcherForTag.appendReplacement(sb, sbreplace.toString());
            result = matcherForTag.find();
        }
        matcherForTag.appendTail(sb);
        return sb.toString();
    }

    /**
     * @param qString
     * @param regx    正则表达式，为空则使用默认正则
     * @return false表示验证通过 返回true表示不通过
     * @des 字符串特殊符号验证
     */
    public static boolean hasCrossScriptRisk(String qString, String regx) {
        if ("".equals(regx)) {
            regx = "!|！|@|◎|#|＃|(\\$)|￥|%|％|(\\^)|……|(\\&)|※|(\\*)|×|(\\()|（|(\\))|）|_|——|(\\+)|＋|(\\|)|§";
        }
        if (qString != null) {
            qString = qString.trim();
            Pattern p = Pattern.compile(regx, Pattern.CASE_INSENSITIVE);
            Matcher m = p.matcher(qString);
            boolean bl = m.find();
            return bl;
        }
        return false;
    }

    /**
     * @param cardId
     * @return
     * @des 校验银行卡卡号
     */
    public static boolean checkBankCard(String cardId) {
        char bit = getBankCardCheckCode(cardId.substring(0, cardId.length() - 1));
        if (bit == 'N') {
            return false;
        }
        return cardId.charAt(cardId.length() - 1) == bit;
    }

    /**
     * @param nonCheckCodeCardId
     * @return
     * @des 从不含校验位的银行卡卡号采用 Luhm 校验算法获得校验位
     */
    public static char getBankCardCheckCode(String nonCheckCodeCardId) {
        if (nonCheckCodeCardId == null || nonCheckCodeCardId.trim().length() == 0
                || !nonCheckCodeCardId.matches("\\d+")) {
            // 如果传的不是数据返回N
            return 'N';
        }
        char[] chs = nonCheckCodeCardId.trim().toCharArray();
        int luhmSum = 0;
        for (int i = chs.length - 1, j = 0; i >= 0; i--, j++) {
            int k = chs[i] - '0';
            if (j % 2 == 0) {
                k *= 2;
                k = k / 10 + k % 10;
            }
            luhmSum += k;
        }
        return (luhmSum % 10 == 0) ? '0' : (char) ((10 - luhmSum % 10) + '0');
    }

    /**
     * @param cardId
     * @return
     * @des 银行卡号，保留最后4位，其他星号替换
     */
    public static String cardIdHide(String cardId) {
        return cardId.replaceAll("\\d{15}(\\d{3})", "**** **** **** **** $1");
    }

    /**
     * @param phone
     * @return
     * @des 手机号码，中间4位星号替换
     */
    public static String phoneNoHide(String phone) {
        // 括号表示组，被替换的部分$n表示第n组的内容
        // 正则表达式中，替换字符串，括号的意思是分组，在replace()方法中，
        // 参数二中可以使用$n(n为数字)来依次引用模式串中用括号定义的字串。
        // "(\d{3})\d{4}(\d{4})", "$1****$2"的这个意思就是用括号，
        // 分为(前3个数字)中间4个数字(最后4个数字)替换为(第一组数值，保持不变$1)(中间为*)(第二组数值，保持不变$2)
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    /**
     * 是否为车牌号（沪A88888）
     */
    public static boolean checkVehicleNo(String vehicleNo) {
        Pattern pattern = Pattern.compile("^[\u4e00-\u9fa5]{1}[a-zA-Z]{1}[a-zA-Z_0-9]{5}$");
        return pattern.matcher(vehicleNo).find();

    }

    /**
     * 验证身份证号码
     *
     * @param idCard 居民身份证号码15位或18位，最后一位可能是数字或字母
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkIdCard(String idCard) {
        String regex = "[1-9]\\d{13,16}[a-zA-Z0-9]{1}";
        return Pattern.matches(regex, idCard);
    }

    /**
     * 验证手机号码
     *
     * @param mobile
     * @return
     */
    public static boolean isMobile(String mobile) {
        Pattern p = Pattern.compile("^(13[0-9]|15([0-3]|[5-9])|14[5,7,9]|17[1,3,5,6,7,8]|18[0-9])\\d{8}$");
        Matcher m = p.matcher(mobile);
        return m.matches();
    }

    /**
     * 验证手机号码（支持国际格式，+86135xxxx...（中国内地），+00852137xxxx...（中国香港））
     *
     * @param mobile 移动、联通、电信运营商的号码段
     *               <p>
     *               移动的号段：134(0-8)、135、136、137、138、139、147（预计用于TD上网卡）
     *               、150、151、152、157（TD专用）、158、159、187（未启用）、188（TD专用）
     *               </p>
     *               <p>
     *               联通的号段：130、131、132、155、156（世界风专用）、185（未启用）、186（3g）
     *               </p>
     *               <p>
     *               电信的号段：133、153、180（未启用）、189
     *               </p>
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkMobile(String mobile) {
        String regex = "(\\+\\d+)?1[3456789]\\d{9}$";
        return Pattern.matches(regex, mobile);
    }

    /**
     * 验证固定电话号码
     *
     * @param phone 电话号码，格式：国家（地区）电话代码 + 区号（城市代码） + 电话号码，如：+8602085588447
     *              <p>
     *              <b>国家（地区） 代码 ：</b>标识电话号码的国家（地区）的标准国家（地区）代码。它包含从 0 到 9 的一位或多位数字，
     *              数字之后是空格分隔的国家（地区）代码。
     *              </p>
     *              <p>
     *              <b>区号（城市代码）：</b>这可能包含一个或多个从 0 到 9 的数字，地区或城市代码放在圆括号—— 对不使用地区或城市代码的国家（地区），则省略该组件。
     *              </p>
     *              <p>
     *              <b>电话号码：</b>这包含从 0 到 9 的一个或多个数字
     *              </p>
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkPhone(String phone) {
        String regex = "(\\+\\d+)?(\\d{3,4}\\-?)?\\d{7,8}$";
        return Pattern.matches(regex, phone);
    }

    /**
     * 验证Email
     *
     * @param email email地址，格式：zhangsan@sina.com，zhangsan@xxx.com.cn，xxx代表邮件服务商
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkEmail(String email) {
        String regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?";
        return Pattern.matches(regex, email);
    }

    /**
     * 验证整数（正整数和负整数）
     *
     * @param digit 一位或多位0-9之间的整数
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkDigit(String digit) {
        String regex = "\\-?[1-9]\\d+";
        return Pattern.matches(regex, digit);
    }

    /**
     * 验证整数和浮点数（正负整数和正负浮点数）
     *
     * @param decimals 一位或多位0-9之间的浮点数，如：1.23，233.30
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkDecimals(String decimals) {
        String regex = "\\-?[1-9]\\d+(\\.\\d+)?";
        return Pattern.matches(regex, decimals);
    }

    /**
     * 验证空白字符
     *
     * @param blankSpace 空白字符，包括：空格、\t、\n、\r、\f、\x0B
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkBlankSpace(String blankSpace) {
        String regex = "\\s+";
        return Pattern.matches(regex, blankSpace);
    }

    /**
     * 验证中文
     *
     * @param chinese 中文字符
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkChinese(String chinese) {
        String regex = "^[\u4E00-\u9FA5]+$";
        return Pattern.matches(regex, chinese);
    }

    /**
     * 验证日期（年月日）
     *
     * @param birthday 日期，格式：1992-09-03，或1992.09.03
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkBirthday(String birthday) {
        String regex = "[1-9]{4}([-./])\\d{1,2}\\1\\d{1,2}";
        return Pattern.matches(regex, birthday);
    }

    /**
     * 验证URL地址
     *
     * @param url 格式：http://blog.csdn.net:80/xyang81/article/details/7705960? 或
     *            http://www.csdn.net:80
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkURL(String url) {
        String regex = "(https?://(w{3}\\.)?)?\\w+\\.\\w+(\\.[a-zA-Z]+)*(:\\d{1,5})?(/\\w*)*(\\??(.+=.*)?(&.+=.*)?)?";
        return Pattern.matches(regex, url);
    }

    /**
     * 匹配中国邮政编码
     *
     * @param postcode 邮政编码
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkPostcode(String postcode) {
        String regex = "[1-9]\\d{5}";
        return Pattern.matches(regex, postcode);
    }

    /**
     * 将半角转成全角
     *
     * @param input
     * @return
     */
    public String ToDBC(String input) {
        char[] c = input.toCharArray();
        for (int i = 0; i < c.length; i++) {
            if (c[i] == 12288) {
                c[i] = (char) 32;
                continue;
            }
            if (c[i] > 65280 && c[i] < 65375)
                c[i] = (char) (c[i] - 65248);
        }
        return new String(c);
    }

    /**
     * 替换、过滤特殊字符
     *
     * @param str
     * @return
     * @throws PatternSyntaxException
     */
    public String StringFilter(String str) throws PatternSyntaxException {
        str = str.replaceAll("【", "[").replaceAll("】", "]").replaceAll("！", "!")
                .replaceAll("“", "\"").replaceAll("”", "\"").replaceAll("，", ",")
                .replaceAll("1", "1 ").replaceAll("2", "2 ").replaceAll("3", "3 ")
                .replaceAll("4", "4 ").replaceAll("5", "5 ").replaceAll("6", "6 ")
                .replaceAll("7", "7 ").replaceAll("8", "8 ").replaceAll("9", "9 ")
                .replaceAll("0", "0 ");// 替换中文标号
        String regEx = "[『』]"; // 清除掉特殊字符
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("");
    }

    /**
     * 产生固定位数随机数
     *
     * @param width 位数
     * @return 字符串
     */
    public static String getRand(int width) {
        Random random = new Random();
        String strRand = "";
        for (int i = 0; i < width; i++) {
            String rand = String.valueOf(random.nextInt(10));
            strRand += rand;
        }
        return strRand;
    }

    /**
     * 将输入流的内容转换成String(字符串)
     *
     * @param is 输入流
     * @return String(字符串)
     */
    public static String getPlainText(InputStream is) {
        try {
            BufferedReader bin = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            StringBuffer sb = new StringBuffer();
            String s = null;
            while ((s = bin.readLine()) != null) {
                sb.append(s);
            }

            return sb.toString();

        } catch (IOException e) {
            e.printStackTrace();
        }

        return "";
    }

    /**
     * 获取性别字符串(1=男、2=女、…=未知)
     *
     * @param sexint 性别代号(int 类型)
     * @return 字符串(String)
     */
    public static String getSexStr(int sexint) {
        if (sexint == 1)
            return "男";
        else if (sexint == 2)
            return "女";
        else
            return "未知";
    }

    /**
     * 获取性别字符串(1=男、2=女、…=未知)
     *
     * @param sexintstr 性别代号(String 类型但内容为数字)
     * @return 字符串(String)
     */
    public static String getSexStr(String sexintstr) {
        try {
            return getSexStr(Integer.parseInt(sexintstr));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return "未知";
    }

    /**
     * 获取当前字符串在数组中第几个item
     *
     * @param strs 数组
     * @param item 要比对的字符串
     * @return 数组中的下标
     */
    public static int getIndexFromArray(String[] strs, String item) {
        int index = 0;
        for (int i = 0; i < strs.length; i++) {
            if (item.equals(strs[i])) {
                index = i;
                break;
            }
        }

        return index;
    }

    /**
     * 将字符串中包含英文‘,’、‘;’替换成中文‘，’、‘；’
     *
     * @param input 字符串
     * @return 新的字符串
     */
    public static String repleaceCNToENSplitChar(String input) {
        input = input.replaceAll(",", "，");
        input = input.replaceAll(";", "；");

        return input;
    }

    /**
     * 格式化输出 字符串 [*]左对齐,右补空格
     *
     * @param str
     * @param min_length : 最小输出长度
     * @return
     */
    public static String formatLeftS(String str, int min_length) {
        String format = "%-" + (min_length < 1 ? 1 : min_length) + "s";
        return String.format(format, str);
    }

    /**
     * 格式化输出 整数 [*]右对齐,左补0
     *
     * @param num
     * @param min_length : 最小输出长度
     * @return
     */
    public static String format0Right(long num, int min_length) {
        String format = "%0" + (min_length < 1 ? 1 : min_length) + "d";
        return String.format(format, num);
    }

    /**
     * 描述：不足2个字符的在前面补“0”.
     *
     * @param str 指定的字符串
     * @return 至少2个字符的字符串
     */
    public static String format0Right(String str) {
        try {
            if (str.length() <= 1) {
                str = "0" + str;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 格式化输出 浮点数 [*]右对齐,左补0
     *
     * @param d
     * @param min_length : 最小输出长度
     * @param precision  : 小数点后保留位数
     * @return
     */
    public static String format0Right(double d, int min_length, int precision) {
        String format = "%0" + (min_length < 1 ? 1 : min_length) + "."
                + (precision < 0 ? 0 : precision) + "f";
        return String.format(format, d);
    }

    /**
     * 取消下划线把吧下划线后面的第一个字母转换成大写
     *
     * @param convert
     * @return
     */
    public static String convertStr(String convert) {
        byte aa[] = convert.getBytes();
        for (int i = 0; i < aa.length; i++) {
            // 下划线的 ASCLL=95小写字母a ASCLL=97大写A ASCLL =65
            if (aa[i] == 95 && aa[i + 1] >= 97 && aa[i + 1] <= 123) {
                aa[i + 1] = (byte) (aa[i + 1] - 32);
            }
        }
        String convert1 = new String(aa);
        return convert1.replace("_", "");
    }

    /**
     * 将String数组转换成String类型
     *
     * @param join   分隔符
     * @param strAry 需要转换的数组
     * @return
     */
    public static String Join(String join, String[] strAry) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < strAry.length; i++) {
            if (i == (strAry.length - 1)) {
                sb.append(strAry[i]);
            } else {
                sb.append(strAry[i]).append(join);
            }
        }

        return new String(sb);
    }

    /**
     * 描述：获取字符串的长度.
     *
     * @param str 指定的字符串
     * @return 字符串的长度（中文字符计2个）
     */
    public static int strLength(String str) {
        int valueLength = 0;
        String chinese = "[\u0391-\uFFE5]";
        if (!TextUtils.isEmpty(str)) {
            // 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1
            for (int i = 0; i < str.length(); i++) {
                // 获取一个字符
                String temp = str.substring(i, i + 1);
                // 判断是否为中文字符
                if (temp.matches(chinese)) {
                    // 中文字符长度为2
                    valueLength += 2;
                } else {
                    // 其他字符长度为1
                    valueLength += 1;
                }
            }
        }
        return valueLength;
    }

    /**
     * 删除字符串开头的字符
     *
     * @param str 字符串；例：000215000
     * @param a   字符；例：0
     * @return 结果：215000
     */
    public static String delStringBeginStr(String str, String a) {
        str = str.replaceFirst("^" + a + "+", "");
        return str;
    }

    /**
     * 删除字符串结尾的字符
     *
     * @param str 字符串；例：000215000
     * @param a   字符；例：0
     * @return 结果：000215
     */
    public static String delStringEndStr(String str, String a) {
        str = str.replaceFirst(a + "+$", "");
        return str;
    }

    /**
     * 小数点后保留两个0
     *
     * @param str 字符串；例：12.0
     * @return 结果：12.00
     */
    public static String getString(String str) {
        if (TextUtils.isEmpty(str)) {
            str = "0.00";
        }
        DecimalFormat df = new DecimalFormat("0.00");
        double d = Double.parseDouble(str);
        return df.format(d);
    }

    /**
     * 小数点后保留两个0
     *
     * @param value 字符串；例：12.0
     * @return 结果：12.00
     */
    public static String ReservedTwoDecimalPlaces(double value) {
        DecimalFormat df = new DecimalFormat("##0.00");
        return df.format(value);
    }

    // 把一个字符串中的大写转为小写或小写转为大写
    public static String exChange(String str) {
        String s = null;
        if (str != null) {
            // 大写转小写
            s = str.toLowerCase();
            // 小写转大写
            // s = str.toUpperCase();

        }

        return s;
    }

    /**
     * 匹配IP地址(简单匹配，格式，如：192.168.1.1，127.0.0.1，没有匹配IP段的大小)
     *
     * @param ipAddress IPv4标准地址
     * @return 验证成功返回true，验证失败返回false
     */
    public static boolean checkIpAddress(String ipAddress) {
        String regex = "[1-9](\\d{1,2})?\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))";
        return Pattern.matches(regex, ipAddress);
    }

}
